Relatório Git Github e Python

Relatório para a disciplina de softwares estatísticos

Introdução:

Aprender ferramentas que facilitam e automatizam nosso trabalho é sempre importante, durante as aulas foi apresentado para nós uma das principais ferramentas de organização e versionamento dos programadores, o Git e o Github (sistema nuvem do Git), essa ferramenta é de suma importância e é uma ferramenta que se deve levar em toda a jornada acadêmica e profissional de um estatístico que está sempre mexendo com programação. O git e github será utilizados também ao decorrer da cadeira durando os ensinamentos de Python. Vamos ver alguns pontos chave dessa ferramenta e um conteudo inicial de python

Git e GitHub:

Uma breve história do Git:

Em meados de (1991-2002) surgia a necessidade de um processo de colaboração mais eficiente ao invés do processo artesanal de correções em arquivos. Dessa necessidade surgiu o BitKeeper, um sistema de controle de versão distribuído, porém, essa solução mais tarde viria a se tornar um problema, em 2005 a BitKeeper rompeu com a Linux deixando a ferramenta disponível apenas no modelo pago, Linus Torvald e seus colaboradores incontentes com a situação se viram determinados a contruir algo novo para substituir o BitKeeper e superar o mesmo, esse algo seria o Git. Mais tarde o que começou como uma resposta imediata a ruptura da BitKeep se tornou uma ferramente dominante de controle de versão.

Uma breve história do Github:

O GitHub nasceu em 2008, criado por Tom Preston-Werner, Chris Wanstrath e PJ Hyett, três desenvolvedores que queriam tornar o Git mais acessível e colaborativo.

Eles perceberam que, embora o Git fosse poderoso, faltava uma plataforma intuitiva para:

• Hospedar repositórios

• Facilitar colaboração em equipe

• Popularizar o controle de versão

Curiosidades:

• Em 2010, já tinha 1 milhão de repositórios.

• Em 2012, o Facebook e o Google adotaram o GitHub.

• Em 2018, a Microsoft comprou o GitHub por US$ 7,5 bilhões – mas manteve-o aberto e independente.

O que são:

Git:

O Git é um sistema de controle de versão distribuído projetado para rastrear mudanças em arquivos e organizar o trabalho entre várias pessoas.

Ao contrário de outros sistemas de versionamento (como Subversion ou CVS), que armazenam arquivos como uma lista de alterações (deltas), o Git trata os dados como um conjunto de snapshots (fotos do estado dos arquivos em um determinado momento). Cada vez que você faz um commit, o Git tira uma “foto” dos arquivos e armazena uma referência a esse estado.

A maioria das operações no Git são feitas localmente, sem precisar de internet. Você pode ver o histórico, criar branches, fazer commits e reverter alterações sem depender de um servidor remoto.

Tudo no Git é verificado por um checksum (hash SHA-1) antes de ser armazenado. Isso significa que é impossível alterar um arquivo ou histórico sem que o Git detecte. Cada arquivo e commit é identificado por um código único de 40 caracteres (ex: 24b9da655...).

Github:

O GitHub é uma plataforma baseada em nuvem em que é possível armazenar, compartilhar e trabalhar com outras pessoas para escrever códigos.

Ao armazenar códigos em um “repositório” no GitHub é possível:

• Demonstrar ou compartilhar seu trabalho.

• Acompanhar e gerenciar alterações no código ao longo do tempo.

• Permitir que outras pessoas revisem o seu código e deem sugestões para melhorá-lo.

• Colaborar em um projeto compartilhado sem se preocupar que suas alterações afetarão o trabalho de seus colaboradores antes que você esteja pronto para integrá-los.

O trabalho colaborativo, uma das características fundamentais do GitHub, é possível graças ao software de código aberto Git, que serviu como base para a criação do GitHub.

Para que servem:

Como mencionado anteriormente, o Git e o GitHub servem como ferramentas complementares para controle de versão e colaboração em projetos. Enquanto o Git atua como sistema de versionamento local, rastreando alterações no código-fonte de maneira eficiente e segura, o GitHub funciona como plataforma de hospedagem em nuvem que potencializa os recursos do Git, adicionando funcionalidades colaborativas.

Dessa forma, Git e GitHub, quando utilizados em conjunto, proporcionam um ambiente robusto e eficiente para o gerenciamento de projetos de software, garantindo rastreabilidade, segurança e colaboração simplificada.

Comandos básicos:

1. git init

   • O comando git init é o primeiro passo para começar a usar o Git em um projeto. Ele cria uma pasta oculta chamada .git dentro do seu diretório, que armazena todos os dados e configurações necessários para o versionamento.

2. git add

   • O git add tem duas funções principais:

     • Começa a rastrear arquivos novos (monitorar os arquivos).

     • Prepara as alterações de arquivos ja existentes, marca como “staged” (preparado).

3. git commit

   • Ele cria um registro permanente no histórico do Git, permitindo que você volte a essa versão quando quiser. É como tirar uma “foto” do seu projeto naquele momentos, guardando todas as alterações preparadas no git add.

4. git push

   • O git push é o comando que envia seus commits locais para um repositório remoto (como GitHub).

5. git pull

   • O git pull é o comando que sincroniza seu repositório local com as alterações mais recentes do repositório remoto (GitHub, GitLab, etc.). Ele combina duas operações:

     • git fetch: Baixa as alterações do remoto.

     • git merge: Integra essas alterações no seu branch local.

6. git clone

   • O git clone é o comando que cria uma cópia local de um repositório Git remoto (como do GitHub, GitLab ou Bitbucket). Ele é usado quando você quer:

     • Trabalhar em um projeto existente (que está na nuvem).

     • Contribuir para um projeto open-source.

     • Iniciar um projeto baseado em um template.

Repositório, commit e brach:

Repositório:

Um repositório é o elemento mais básico do Git e do GitHub. É um lugar onde você pode armazenar seu código, seus arquivos e o histórico de revisão de cada arquivo. Contém snapshots (fotos instantâneas) de todos os arquivos em cada versão. Mantém um histórico completo de alterações (quem modificou, quando e o que mudou). Permite ramificação (branches) para desenvolvimento paralelo.

• Local: Armazenado no seu computador (pasta .git).

• Remoto: Hospedado em plataformas como GitHub. Os repositórios podem ter vários colaboradores e podem ser públicos ou particulares.

Commit:

Um commit registra alterações em um ou mais arquivos no seu branch, parecido com salvar um arquivo qualquer que foi editado. O Git atribui a cada commit um ID exclusivo, denominado SHA ou hash, que identifica:

• Cada uma das alterações feitas;

• O momento em que as alterações foram feitas;

• O autor das alterações.

Ao fazer um commit, você deve colocar uma mensagem que descreva brevemente as alterações.

Branch:

É uma linha de desenvolvimento separada, que permite aos desenvolvedores trabalhar em diferentes partes do projeto sem interferir no código principal. É muito usado para fazer testes no aequivo principal ou quando tem vários colaboradores no projeto, assim cada um faz um branch diferente e depois juntam tudo no main. Por exemplo:

git branch menu-navegacao    # Cria o branch
git checkout menu-navegacao  # Entra nele

Mexendo nele:

git add .
git commit -m "Adiciona menu"

Voltando para o branch principal (main):

git checkout main  # Volta para o branch original

pip:

O pip é o instalador de pacotes padrão do Python. Ele serve para baixar, instalar e gerenciar bibliotecas que não vêm junto com o Python, mas que são muito úteis para desenvolver projetos.

Com o pip, conseguimos acessar milhares de pacotes disponíveis no repositório oficial do Python, o PyPI.

Como instalar pacotes com pip:

Para instalar uma biblioteca com o pip, usamos o seguinte comando no terminal ou prompt de comando:

pip install nome-do-pacote

Por exemplo, para instalar o pacote pandas:

pip install pandas

Isso faz com que o pip baixe e instale automaticamente a biblioteca em seu ambiente Python.

Como atualizar o próprio pip

O pip pode ser atualizado por ele mesmo com o seguinte comando:

python -m pip install --upgrade pip

Esse comando usa o próprio Python para rodar o pip como módulo e garantir que ele seja atualizado para a versão mais recente.

Exemplos de bibliotecas populares

pandas

Usada para análise e manipulação de dados. Trabalha com estruturas como tabelas (DataFrames), séries temporais e arquivos CSV, Excel, entre outros.

Instalação:

pip install pandas

numpy

Fornece suporte a arrays, operações matemáticas e álgebra linear de forma rápida e eficiente. É a base para muitas bibliotecas científicas no Python.

Instalação:

pip install numpy

matplotlib

Utilizada para criar gráficos e visualizações de dados. Permite gerar gráficos de linha, barra, dispersão, histogramas e mais.

Instalação:

pip install matplotlib

requests

Facilita a realização de requisições HTTP, como acessar APIs ou páginas da internet, de forma simples e eficiente.

Instalação:

pip install requests

Conceitos iniciais de Python:

Tipos de dados: interger, float, string, boolean:

Um valor é uma das coisas básicas com as quais um programa trabalha, como uma letra ou um número. Esses valores pertencem a tipos diferentes: 2 é um número inteiro, 42.0 é um número de ponto flutuante e ‘Hello, World!’ é uma string (string é chamado assim pois são letras em uma sequência em cadeia).

Para ter certeza dos tipos que esses valores assumem podemos pedir para o própio python dizer qual tipo cada um pertence:

print(type(4))
> class 'int'
print(type(21.0))
> class 'float'
print(type('Hello, World!'))
> class 'str'
print(type(TRUE))
> class 'bool'

E ao colocar valores como ‘4’ e ‘21.0’, eles parecem números mas vão ser tratados como string por estarem entre aspas:

print(type('4'))
> class 'str'
print(type('21.0'))
> class 'str'

Sintetizando tudo vamos ter os seguinte tipos de valores:

Tipo	Descrição	Exemplo
int	Números inteiros	42, -7
float	Números decimais	3.14, -0.001
str	Sequências de caracteres	"Python"
bool	Valores booleanos	True, False

Variáveis e operadores básicos:

Uma variável é um nome que se refere a um valor. Uma instrução de atribuição cria uma nova variável e dá um valor a ela:

mensagem = 'relatório de python'
n = 17
pi = 3.141592

Esse exemplo faz três atribuições. A primeira atribuiu uma string a uma nova variável chamada mensagem; a segunda dá o número inteiro 17 a n; a terceira atribui o valor a pi.

Uma forma comum de representar variáveis por escrito é colocar o nome com uma flecha apontando para o seu valor. Este tipo de número é chamado de diagrama de estado porque mostra o estado no qual cada uma das variáveis está:

Figura 1 – Diagrama de estado.

Programadores geralmente escolhem nomes objetivos para suas variáveis, isso ajuda a entender o propósito da variável no código.

Os nomes de variáveis podem ter qualquer tamanho e podem incluir letras e números. No entanto, eles não podem começar com um número. Embora seja permitido usar letras maiúsculas, é comum utilizar apenas letras minúsculas para nomear variáveis.

O caractere de sublinhado (_) também é permitido e costuma ser usado para separar palavras em nomes compostos, como em nome_do_usuario ou relatorio_pip.

Caso você tente usar um nome inválido, o Python retornará um erro de sintaxe:

76trombones = 'big parade'
>SyntaxError: invalid syntax

more@ = 1000000
>SyntaxError: invalid syntax

class = 'Advanced Theoretical Zymurgy'
>SyntaxError: invalid syntax

• 76trombones não é aceito porque começa com um número.

• more@ é inválido porque o símbolo @ não pode fazer parte de nomes de variáveis.

• Já class causa erro porque é uma palavra reservada da linguagem.

Essas palavras reservadas têm significados especiais no Python e não podem ser usadas como identificadores (nomes de variáveis, funções, etc.).

Aqui estão as palavras-chave da linguagem Python 3:

Palavra-chave
and	del	from	None
as	elif	global	nonlocal
assert	else	if	not
break	except	import	or
class	False	in	pass
continue	finally	is	raise
def	for	lambda	return
True	try	while	with
yield

Os operadores +, -, * e / executam a adição, a subtração, a multiplicação e a divisão como mostra os exemplos:

print(20 + 1) 
>21
print(22 - 1)
>21 
print(3 * 7)
>21
print(42 / 2)
>21.0

Listas, tuplas e dicionários:

Listas (list):

As listas são como caixas onde você pode guardar vários itens em uma ordem específica. Elas aceitam mudanças: dá pra adicionar, remover e alterar elementos quando quiser.

Exemplo:

frutas = ["maçã", "banana", "laranja"] 
print(frutas[0])  # mostra "maçã"  
frutas.append("uva")  # adiciona "uva" 
frutas[1] = "melancia"  # troca "banana" por "melancia" 

Principais comandos:

• append(): adiciona no final

• remove(): remove um valor

• len(lista): mostra o tamanho

• Índices: lista[0], lista[-1], etc.

Tuplas (tuple):

As tuplas são parecidas com listas, mas com um detalhe importante: não podem ser alteradas. Depois de criadas, ficam travadas. Por isso são boas pra guardar dados que não devem mudar.

Exemplo:

coordenadas = (10, 20) 
print(coordenadas[1])  # mostra 20 

É recomendado usar quando você quer garantir que os dados não sejam modificados por engano.

Dicionários (dict):

Um dicionário se parece com uma lista, mas é mais geral. Em uma lista, os índices têm que ser números inteiros; em um dicionário, eles podem ser de (quase) qualquer tipo.

Um dicionário contém uma coleção de índices, que se chamam chaves e uma coleção de valores. Cada chave é associada com um único valor. A associação de uma chave e um valor chama-se par chave-valor ou item.

Dicionários são definidos entre chaves {} onde cada item é um par na forma de chave:valor, separados por ,, sendo a chave e o valor podendo ser de qualquer tipo.

Chaves:

• Devem ser únicas

• Tipo imutável (int, float, string, tuple, bool)

• Nenhuma ordem para chaves ou valores

Valores:

• Qualquer tipo (imutável e mutável)

• Pode ser duplicado

• Valores de dicionários podem ser listas, até mesmo outros dicionários

O código abaixo representa um exemplo de dicionário ao qual atribuímos a variável pessoa:

pessoa = {"nome": "Paulo", "idade": 29, "filhos": ["João", "Maria"]}

Estruturas de controle: if, else, elif, for, while:

As instruções if, elif e else são usadas em Python para nos auxiliar na tomada de decisões. A tomada de decisão é um conceito muito importante da programação e representa a capacidade de executarmos determinados comandos apenas se condições especificadas forem satisfeitas.

O python é capaz de suportar as condições lógicas tradicionais da matemática:

• Igualdade: x == y

• Diferente de: x != y

• Menor que: x < y

• Menor que ou igual a: x <= y

• Maior que: x > y

• Maior que ou igual a: x >= y

A sintaxe para construirmos uma estrutura de tomada de decisão funciona então da seguinte forma:

if <expressão>:
    <comandos>
elif <expressão>:
    <comandos>
else:
    <comandos>

Exemplo:

a = 100
b = 20

if b > a:
    print("b é maior do que a")
elif b == a:
    print("b e a são iguais")
else:
    print("a é maior do que b")

O for loop em Python representa uma das formas mais comuns de estrutura de repetição, permitindo iterar sobre uma sequência de elementos e executar um bloco de código múltiplas vezes. Em Python, o for loop é muito flexível e pode iterar sobre listas, strings, tuplas, dicionários e outros iteráveis.

Exemplo:

frutas = ['maçã', 'banana', 'cereja']
for fruta in frutas:
    print(fruta)

> maça
> banana
> cereja

A sintaxe do for loop funciona da seguinte maneira:

valores = [10, 20, 30] 
for valor in valores:     
    print(f'O valor é: {valor}')

> O valor é: 10
> O valor é: 20
> O valor é: 30

• Definição de um iterável: no caso, criamos uma lista chamada valores com três elementos: 10, 20 e 30.

• Início do for loop: a linha for valor in valores: inicia o for loop. A variável valor armazena cada elemento da lista valores durante a iteração.

• Bloco de código indentado: a função print(f’O valor é: {valor}’) exibe o valor atual de valor na tela.

O for loop continua a iterar até que todos os elementos da lista tenham sido processados. A indentação é crucial em Python, pois indica quais linhas de código pertencem ao bloco do for loop.

O while é uma estrutura de repetição utilizada quando queremos que determinado bloco de código seja executado enquanto (do inglês while) determinada condição for satisfeita.

Em outras palavras: só saia da estrutura de repetição quando a condição não for mais satisfeita.

Sua sintaxe básica é:

while <condição>:
    # Bloco a ser executado

Aqui, é uma expressão que pode ser reduzida à True ou False, podendo ser:

• A verificação do valor de uma variável

• Determinada estrutura de dados alcançar um tamanho

• O retorno de uma função se igualar a determinado valor

• Algum valor externo ser alterado (por exemplo um valor armazenado em Banco de Dados).

Exemplo:

contador = 0

while contador < 10:
    print(f'Valor do contador é {contador}')
    contador += 1

Resultando :

Valor do contador é 1
Valor do contador é 2
Valor do contador é 3
Valor do contador é 4
Valor do contador é 5
Valor do contador é 6
Valor do contador é 7
Valor do contador é 8
Valor do contador é 9
Valor do contador é 10

Ou seja, a variável contador está sendo incrementada a cada vez que o while executa seu código.

Quando ele alcançar o valor 10, a condição contador < 10 não será mais satisfeita, finalizando o bloco while.

Funções: def, parâmetros, retorno:

Uma função é um bloco de código organizado e reutilizável que é capaz de realizar uma determinada ação. Funções nos ajudam a deixar o nosso código mais modular, trazendo a possibilidade de reusabilidade, conforme nosso programa fica cada vez maior, as funções o tornam mais organizado e gerenciável.

As funções seguem algumas regras, sendo elas:

1. Para criar uma nova função em Python, a palavra reservada def é utilizada.

2. Em seguida, é atribuído um nome ao identificador que será usado para chamá-la.

3. Depois do nome, uma lista opcional de parâmetros é incluída entre parênteses.

4. O cabeçalho da função termina com dois pontos.

5. Nas linhas seguintes, com uma indentação maior vem o corpo da função, ou seja, uma sequência de sentenças que executam uma operação.

6. Por último, opcionalmente, é adicionada a palavra reservada return para devolver um resultado.

A sintaxe da função funciona da seguinte maneira:

def nome (parâmetro):
bloco de código
return

Os parâmetros de input ou argumentos (dados fornecidos por nós) devem ser colocados entre parenteses (), eles determinam os valores das variáveis que estão contidas dentro do bloco de código, porém eles são opcionais.

Podemos definir parâmetros padrão para caso a função seja invocada sem nenhum argumento passado, estes preencherão as opções:

def padrao(valor=100):
    #Função que apenas imprime um valor
    print("O valor definido foi: " + str(valor))
    
padrao() # 100
padrao(10) # 10
padrao(33) # 33

O comando return nos permite fazer com que a função retorne um valor e possamos armazená-lo em uma variável, por exemplo:

def func(x):
    return x + 1 
y = func(1)
z = func(2)
print(y) # 2
print(z) # 3

Importação de bibliotecas com import:

Biblioteca é um arquivo que contém definições e comandos/instruções Python.

Uma biblioteca (também chamada de módulo) pode conter tanto instruções executáveis quanto definições de funções e classes. Essas instruções servem para inicializar o módulo. Eles são executados somente na primeira vez que a biblioteca é encontrado em uma instrução de importação.

Podemos imaginar um módulo como um conjunto de ferramentas disponíveis para usarmos para solucionar determinados problemas.

Supomos que temos um módulo chamado matematica. Os principais formatos para importarmos nossos módulos são:

import matematica

• Tudo que está no módulo matematica é importado

• Para se referir aos métodos de matematica, adicionamos o prefixo “matematica” em frente ao seu nome

matematica.nomeclasse.metodo()
matematica.funcao()

Importando usando o asterisco *:

from matematica import *

• Tudo no módulo matematica é importado

• Para se referir a qualquer método no módulo, basta usar seu nome, sem precisarmos prefixar

• Lembre de ter atenção ao usar esse tipo de import, pois ele pode sobrescrever a definição de uma variável ou função já existente

nomeclasse.metodo()
funcao()

Importando uma classe ou função específica:

from matematica import nomeclasse

• Apenas o item nomeclasse será importado

• Após importar nomeclasse você pode usar ele sem o prefixo do módulo, ele é colocado no namespace atual

• Tome cuidado ao usar, pois pode sobrescrever a definição do nome, caso ele já esteja no namespace

nomeclasse.metodo()
funcao()

Além de funções, os módulos também podem conter variáveis e estruturas de dados (listas, tuplas, dicionários, objetos). Vamos então criar mais um módulo para testarmos, nomearemos o nosso arquivo como estudantes.py.

estudantes = [
    {'nome':'Uriel','idade':27,'aprovado':True},
    {'nome':'Emanuel','idade':25,'aprovado':True},
    {'nome':'Malthael','idade':29,'aprovado':False}
]
def imprimir_aprovados():
    for estudante in estudantes:
        if estudante['aprovado']:
            print(f'{estudante["nome"]} está aprovado')

Iremos agora importar o módulo estudantes e podemos acessar a lista de dicionários estudantes, perceba que fornecemos o mesmo nome para ambos, mas isso é uma escolha livre que temos. Também temos acesso a função para imprimir os estudantes que estão aprovados.

from estudantes import *

estudante = estudantes[2]['nome']
print(estudante) # Malthael

Podemos dar um apelido para um módulo, tornando-o mais fácil de nos referirmos a ele, para isso usamos a palavra-chave as:

import estudantes as e

print(e.estudantes[0]['idade']) # 27
e.imprimir()
# Uriel está aprovado
# Emanuel está aprovado

Boas práticas: comentários, nomes de variáveis, indentação:

Referências